import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Practice {




//    扫描指定目录，并找到名称或者内容中包含指定字符的所有普通文件（不包含目录）
//    注意：我们现在的方案性能较差，所以尽量不要在太复杂的目录下或者大文件下实验

    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入要查找的路径（绝对路径 OR 相对路径): ");
        String Path = scanner.next();
        File rootPath = new File(Path);
        // 检查输入
        if(!rootPath.exists() || !rootPath.isDirectory()){
            System.out.println("输入的路径有误，程序退出");
            return;
        }
        // 获取要查找的指定名称或内容
        System.out.print("请输入要查找的内容: ");
        String targetContent = scanner.next();
        List<File> result = new ArrayList<>();
        // 因为文件是树形结构， 所以我们使用深度优先遍历完成遍历
        try {
            scanDirWithContent(rootPath, targetContent, result);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        System.out.println("共找到了符合条件的文件 " + result.size() + " 个，它们分别是");
        for(File file: result){
            System.out.println(file.getCanonicalPath());
        }
    }


    private static void scanDirWithContent(File rootDir, String Content, List<File> result) throws IOException{
        File[] files = rootDir.listFiles();
        if(files==null || files.length==0){
            return;
        }
        for (File file :files) {
            if(file.isDirectory()){
                scanDirWithContent(file, Content, result);
            }else {
                if(isContentContains(file, Content)){
                    result.add(file.getAbsoluteFile());
                }
            }
        }
    }

    private static boolean isContentContains(File file, String Content) throws IOException{
        StringBuilder sb = new StringBuilder();
        try(InputStream is = new FileInputStream(file)){
            try(Scanner scanner = new Scanner(is, "UTF-8")){
                while(scanner.hasNextLine()){
                    sb.append(scanner.nextLine());
                    sb.append("\r\n");
                }
            }
        }
        return sb.indexOf(Content) != -1;
    }


    public static void main6(String[] args) throws FileNotFoundException {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入要查找的路径（绝对路径 OR 相对路径): ");
        String Path = scanner.next();
        File rootPath = new File(Path);
        // 检查输入
        if(!rootPath.exists() || !rootPath.isDirectory()){
            System.out.println("输入的路径有误，程序退出");
            return;
        }
        // 获取要查找的指定名称或内容
        System.out.println();
        System.out.print("请输入要查找的内容: ");

        String targetContent = scanner.next();
        ArrayList<File> fileLists = new ArrayList<>();

        // 开始找
        for (File file :rootPath.listFiles()) {
            // 将 file  分为 文件和目录来分别处理对待
            if(file.isFile()){
                // 验证文件名 和  文件内容，  将内容读进 String ，然后用contenr来检测
                String name = file.getName();
                try(Scanner readFile = new Scanner(file)){
                    String fileContent = readFile.next();
                    // 我这里出现的报错很有可能就是因为读取的文件为空，而出现了空指针异常
                    if(name.contains(targetContent) || fileContent.contains(targetContent)){
                        fileLists.add(file);
                    }
                }
            }
            // 如果目录也要包含进来的话， 那么用递归或者利用 栈来保存遍历的记录
        }
        // 这里将结果写出来
        for (File file : fileLists) {
            System.out.println(file.getName());
        }

    }


    public static void main5(String[] args) throws IOException {
           Scanner scanner = new Scanner(System.in);
           System.out.println("请输入要复制的文件（绝对路径 OR 相对路径): ");
           String sourcePath = scanner.next();
           File sourceFile = new File(sourcePath);
           if(!sourceFile.exists()){
               System.out.println("文件不存在，请去让人路径是否正确");
               return;
           }
           if(!sourceFile.isFile()){
               System.out.println("文件不是普通文件，请确认路径是正确的");
               return;
           }
           System.out.println("请输入要复制到的目标路径（绝对路径 OR 相对路径）:");
           String destPath = scanner.next();
           File destFile = new File(destPath);
           if(destFile.exists()){
               if(destFile.isDirectory()){
                   System.out.println("目标路径已经存在，并且是一个目录，请确认路径是否正确");
                   return;
               }

               if(destFile.isFile()){
                    System.out.println("目录路径已经存在，是否要进行覆盖?y/n");
                    String ans = scanner.next();
                    if(!ans.toLowerCase().equals("y")){
                        System.out.println("停止复制");
                        return;
                    }
               }
           }
           try(InputStream is = new FileInputStream(sourceFile)){
               try(OutputStream os = new FileOutputStream(destFile)){
                   byte[] buf = new byte[1024];
                   int len;
                   // 这种写法是认为  一次就能够读取完毕吗
                   while(true){
                        len = is.read(buf);
                        if(len == -1){
                            break;
                        }
                        os.write(buf,0,len);           // 即使赐福很多，也能完完整整的打印出来，
                   }
                   os.flush();
               }
           }
            System.out.println("复制已完成");

    }

    // 自己写的 文件复制操作成功了
    public static void main4(String[] args) throws IOException {
        // 设计普通文件的复制操作
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入要复制的文件，绝对路径/相对路径: ");
        String FilePath = scanner.next();

        File srcfile = new File(FilePath);
        if(!srcfile.exists() || srcfile.isDirectory()){
            // 表示文件不存在
            System.out.println("您输入的文件不存在，退出程序");
            return;
        }else{
            System.out.print("请输入要复制到的目标路径（绝对路径/相对路径）");
            String desPath = scanner.next();
            File desFile = new File(desPath);
            if(!desFile.isDirectory() || !desFile.exists()){
                System.out.println("您输入的路径有误，程序退出");
                return;
            }
            // 下一步检查下该目录下的文件有没有同名的，如果有，询问是否需要覆盖，如果没有，那么创建文件，并复制内容
            String tarFileName = desPath+"\\"+ srcfile.getName();
            System.out.println(tarFileName);
            File targetfile = new File(tarFileName);

            if(targetfile.exists()){
                System.out.println("目标路径下已有同名文件，是否覆盖(y/n):");
                String dec = scanner.next();
                if(dec.toLowerCase().equals("y")){
                    // 执行覆盖操作
                    CpFile(srcfile, targetfile);
                }
                else{
                    System.out.println("拒绝覆盖，程序退出");
                    return;
                }
            }else { // 说明原来不存在文件， 那么创建新的文件
                targetfile.createNewFile();
                CpFile(srcfile, targetfile);
            }
        }
    }

    private static void CpFile(File src, File des) throws IOException {
        // 对文件分别执行读和写操作
        Scanner scanner = new Scanner(src);
        String srcContent = "";
        while(scanner.hasNext()){
            srcContent = scanner.next();
        }
        // 读完原文件的全部内容
        // 开始写       写文件这里出了问题， 没有成功把东西叶静如
//        System.out.println(des.getCanonicalPath());
//        System.out.println(des.getName());

        PrintWriter output = new PrintWriter(des);
        output.write(srcContent);
        output.flush();
        output.close();

    }

    public static void main3(String[] args) {

//        String one = "10";
//        System.out.println("10".equals(10));
//        System.out.println("10".equals("10"));
//        System.out.println("10".equals(one));
    }

    public static void main1(String[] args) {
        // try-catch block to handle exceptions
        try {

            // create a file object
            File f = new File("program.txt");

            // create a file with the absolute path
            // of file f
            File absolute = f.getAbsoluteFile();

            // display the file path of the file object
            // and also the file path of absolute file
            System.out.println("Original file path : "
                    + f.getPath());
            System.out.println("Absolute file path : "
                    + absolute.getPath());
        }
        catch (Exception e) {
            System.err.println(e.getMessage());
        }
    }

    public static void main2(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入要扫描的根目录（绝对路径 OR 相对路径):");
        String rootDirPath = scanner.next();

        File rootDir = new File(rootDirPath);
        if(!rootDir.isDirectory()){
            System.out.println("您输入的根目录不存在或者不是目录");
            return;
        }

        System.out.print("请输入要找出的文件名中的字符:");
        String token = scanner.next();
        List<File> result = new ArrayList<>();
        // 自定义函数， 进行深度遍历找文件
        scanDir(rootDir,token, result);
        System.out.print("共找到了符合条件的文件 " + result.size() + " 个，它们分别是");

        for (File file: result) {
            System.out.println(file.getCanonicalPath() + " 请问您是否要删除该文件？y/n");
            String in = scanner.next();
            if(in.toLowerCase().equals("y")){
                file.delete();
            }
        }
    }

    private static void scanDir(File rootDir, String token, List<File> result){
        File[] files = rootDir.listFiles();
        //  获取 文件夹下所有的文件对象
        if(files == null || files.length==0){
            return;
        }
        for (File file:files){
            if(file.isDirectory()){
                scanDir(file, token, result);
            }else {
                if(file.getName().contains(token)){
                    result.add(file.getAbsoluteFile());
                    System.out.println(file.getAbsolutePath());
                }
            }
        }

    }

}
